home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Highlands / Highlands Small.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  51.5 KB  |  1,549 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Highlands Small.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 8/28/01 3:36p $
  11. // $Revision: 26 $
  12. // $Revision: 26 $Revision: 8
  13. //   Adjusted Angle between team members 
  14. // $Revision:
  15. //  Revision: 13 Lowered elevation, added neutrals, pushed players outward,
  16. //               lowered player outer radius, increased tree %, reduced
  17. //               forest free radius, reduced resource to edge distance
  18. //             Assumes Highlands Initial Step = 8
  19. //  Revision: 15 Revised for miniaturization 
  20. //  Revision: 16 Elevation 
  21. //  Revision: 17 Revised # of resources 3 by 3
  22. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  23. //  Revision: 19 Created a new map size
  24. //  Revision: 20 Reduced congestion
  25. //  Revision: 20b Increased elevation
  26. //  Revision: 20c Small adjustments
  27. //  Revision: 23 Reduced Resources
  28. //  Revision: 24 Added Chance of steep cliffs
  29. //  Revision: 25 Two forage sites for Prehistoric Start 
  30. //  Revision: 26 Evened-out resource distribution 
  31. //  Revision: 26b Created neutral berry bushes for Prehistoric starts 
  32. //  Revision: 26h Eliminated starts in which players surrounded by mountains
  33. //  Revision: 28 Moved resources 2 tiles further from Capitol
  34. //
  35. //////////////////////////////////////////////////////////////////////
  36.  
  37. #if            NOTDEFINED(HIGHLANDS_SMALL_RMV)
  38. #define        (HIGHLANDS_SMALL_RMV,1)
  39.  
  40. //////////////////////////////////////////////////////////////////////
  41. // Definitions we are required to define for highlands maps
  42. //////////////////////////////////////////////////////////////////////
  43.  
  44. ResourcePlacementLimit (Gold,     8,    11)
  45. ResourcePlacementLimit (Steel,     8,     11)
  46. ResourcePlacementLimit (Stone,     8,     11)
  47. ResourcePlacementLimit (Berry,     7,     10)
  48. ResourcePlacementLimit (Fish,     1,    50)
  49. ResourcePlacementLimit (Tree,     3,     6)
  50. ResourcePlacementLimit (Animal,     7,     15)
  51.  
  52. #if Is2Players
  53. //////////////////////////////////////////////////////////////////////
  54. // 2 PLAYERS...
  55. //////////////////////////////////////////////////////////////////////
  56.  
  57. //////////////////////////////////////////////////////////////////////
  58. // terrain definitions
  59.  
  60. #if        PERCENT(80)
  61.   #define        (kMaxIntElevation,            9)
  62. #else
  63.   #define        (kMaxIntElevation,            15)
  64. #endif
  65.  
  66. #define        (kElevationScale,                Between(1, 1))
  67. #define        (kHeightMapChaos,                Between(20, 25))
  68.                                             
  69. #define        (kMinimumStartPositionToMapEdge    4)
  70. #define        (kOuterPushFromMapCenter        20)
  71. #define        (kInnerPushFromMapCenter         0)    
  72.  
  73. #define        (kConvergentSampleSize,            32) 
  74. #define        (kConvergentThreshold,            2000)    
  75.  
  76. //////////////////////////////////////////////////////////////////////
  77. // player definitions
  78. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  79. #define        (kPlayerInnerRadius,            0.6)
  80. #define        (kPlayerOuterRadius,            0.8)
  81. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  82. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  83. #define        (kPlayerLandChaos,            0.8)
  84. #define        (kPlayerLandClumps,            Between(1, 1))
  85. #define        (kPlayerFlatChaos,            0.8)
  86. #define        (kPlayerFlatClumps,            Between(1, 1))
  87. #define        (kPlayerTreePercentage,            0.06)
  88.  
  89.  
  90. //////////////////////////////////////////////////////////////////////
  91. // inner neutral definitions
  92. #define        (kNeutralInnerRadius,            0.35)
  93. #define        (kNeutralOuterRadius,            0.35)
  94. #define        (kNeutralOptimalFactor,            0.7)
  95. #define        (kNumInnerNeutrals,                 Between(4, 4))
  96. #define        (kInnerNeutralPercentLand,        0.2)
  97. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  98. #define        (kInnerNeutralTreePercentage,          0.12)
  99. #define        (kInnerNeutralLandChaos,        0.8)
  100. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  101. #define        (kInnerNeutralFlatChaos,        0.8)
  102. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  103.  
  104.  
  105. //////////////////////////////////////////////////////////////////////
  106. // outer neutral definitions
  107. #define        (kNumOuterNeutrals,            Between(10, 10))
  108. #define        (kOuterNeutralPercentLand,        0.6)
  109. #define        (kOuterNeutralPercentFlat,        0.99)
  110. #define        (kOuterNeutralTreePercentage,          0.13)
  111. #define        (kOuterNeutralLandChaos,        0.8)
  112. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  113. #define        (kOuterNeutralFlatChaos,        0.8)
  114. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  115.  
  116.  
  117. //////////////////////////////////////////////////////////////////////
  118. // resource definitions
  119. #define        (kMaxResourceElevation,            3)
  120. #define        (kResourceToEdgeDistance,        2)
  121. #define        (kResourceToWaterDistance,        3)
  122.  
  123. #define        (kAnimalPerPlayer,            0)
  124. #define        (kAnimalPerNeutral,            0)
  125.  
  126. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  127.   #define  (kBerryPerPlayer,    1) 
  128.   #define  (kBerryPerNeutral,      4)
  129. #else
  130.   #define  (kBerryPerPlayer,    1)
  131.   #define  (kBerryPerNeutral,      0)
  132. #endif 
  133.  
  134. #define        (kFishPerPlayer,                0)
  135. #define        (kFishPerNeutral,                0)
  136.  
  137. #define        (kGoldPerPlayer,                1)
  138. #define        (kGoldPerNeutral,                4)
  139.  
  140. #define        (kOilPerPlayer,                0)
  141. #define        (kOilPerNeutral,                0)
  142.  
  143. #define        (kSteelPerPlayer,                1)
  144. #define        (kSteelPerNeutral,            4)
  145.  
  146. #define        (kStonePerPlayer,                1)
  147. #define        (kStonePerNeutral,            2)
  148.  
  149. #define        (kTreePerPlayer,                1)
  150. #define        (kTreePerNeutral,                0)
  151.  
  152.  
  153. //////////////////////////////////////////////////////////////////////
  154. // forest definitions
  155. #define        (kForestFreeRadius,                9.0)
  156. #define        (kForestsPerPlayer,                1)
  157. #define        (kForestChaosLevel,                0)
  158. #define        (kMaxClumpsPerForest,                  1)
  159.  
  160. #elif Is3Players
  161. //////////////////////////////////////////////////////////////////////
  162. // 3 PLAYERS...
  163. //////////////////////////////////////////////////////////////////////
  164.  
  165. //////////////////////////////////////////////////////////////////////
  166. // terrain definitions
  167.  
  168. #if        PERCENT(80)
  169.   #define        (kMaxIntElevation,            10)
  170. #else
  171.   #define        (kMaxIntElevation,            14)
  172. #endif 
  173.  
  174. #define        (kElevationScale,                Between(1, 1))
  175. #define        (kHeightMapChaos,                Between(16, 18))
  176.  
  177. #define        (kMinimumStartPositionToMapEdge    5)
  178. #define        (kOuterPushFromMapCenter        20)
  179. #define        (kInnerPushFromMapCenter         0)    
  180.  
  181. #define        (kConvergentSampleSize,            4) 
  182. #define        (kConvergentThreshold,            10)    
  183.                                             
  184. //////////////////////////////////////////////////////////////////////
  185. // player definitions
  186. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  187. #define        (kPlayerInnerRadius,            0.6)
  188. #define        (kPlayerOuterRadius,            0.8)
  189. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  190. #define        (kPlayerPercentFlat,            Between(0.98, 0.98))
  191. #define        (kPlayerLandChaos,            0.8)
  192. #define        (kPlayerLandClumps,            Between(1, 1))
  193. #define        (kPlayerFlatChaos,            0.8)
  194. #define        (kPlayerFlatClumps,            Between(1, 1))
  195. #define        (kPlayerTreePercentage,            0.06)
  196.  
  197.  
  198. //////////////////////////////////////////////////////////////////////
  199. // inner neutral definitions
  200. #define        (kNeutralInnerRadius,            0.3)
  201. #define        (kNeutralOuterRadius,            0.3)
  202. #define        (kNeutralOptimalFactor,            0.7)
  203. #define        (kNumInnerNeutrals,            Between(4, 4))
  204. #define        (kInnerNeutralPercentLand,        0.2)
  205. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  206. #define        (kInnerNeutralTreePercentage,          0.12)
  207. #define        (kInnerNeutralLandChaos,        0.8)
  208. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  209. #define        (kInnerNeutralFlatChaos,        0.8)
  210. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  211.  
  212. //////////////////////////////////////////////////////////////////////
  213. // outer neutral definitions
  214. #define        (kNumOuterNeutrals,            Between(8, 8))
  215. #define        (kOuterNeutralPercentLand,        0.53)
  216. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  217. #define        (kOuterNeutralTreePercentage,          0.12)
  218. #define        (kOuterNeutralLandChaos,        0.8)
  219. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  220. #define        (kOuterNeutralFlatChaos,        0.8)
  221. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  222.  
  223. //////////////////////////////////////////////////////////////////////
  224. // resource definitions
  225. #define        (kMaxResourceElevation,            3)
  226. #define        (kResourceToEdgeDistance,        2)
  227. #define        (kResourceToWaterDistance,        4)
  228.  
  229. #define        (kAnimalPerPlayer,            0)
  230. #define        (kAnimalPerNeutral,            0)
  231.  
  232. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  233.   #define  (kBerryPerPlayer,    1) 
  234.   #define  (kBerryPerNeutral,      6)
  235. #else
  236.   #define  (kBerryPerPlayer,    1)
  237.   #define  (kBerryPerNeutral,      0)
  238. #endif 
  239.  
  240. #define        (kFishPerPlayer,                0)
  241. #define        (kFishPerNeutral,                0)
  242.  
  243. #define        (kGoldPerPlayer,                1)
  244. #define        (kGoldPerNeutral,                6)
  245.  
  246. #define        (kOilPerPlayer,                0)
  247. #define        (kOilPerNeutral,                0)
  248.  
  249. #define        (kSteelPerPlayer,                1)
  250. #define        (kSteelPerNeutral,            6)
  251.  
  252. #define        (kStonePerPlayer,                1)
  253. #define        (kStonePerNeutral,            3)
  254.  
  255. #define        (kTreePerPlayer,                1)
  256. #define        (kTreePerNeutral,                0)
  257.  
  258.  
  259. //////////////////////////////////////////////////////////////////////
  260. // forest definitions
  261. #define        (kForestFreeRadius,                9.0)
  262. #define        (kForestsPerPlayer,                1)
  263. #define        (kForestChaosLevel,                0)
  264. #define        (kMaxClumpsPerForest,                  1)
  265.  
  266. #elif Is4Players
  267. //////////////////////////////////////////////////////////////////////
  268. // 4 PLAYERS...
  269. //////////////////////////////////////////////////////////////////////
  270.  
  271. //////////////////////////////////////////////////////////////////////
  272. // terrain definitions
  273.  
  274. #if        PERCENT(80)
  275.   #define        (kMaxIntElevation,            10)
  276. #else
  277.   #define        (kMaxIntElevation,            14)
  278. #endif 
  279.  
  280. #define        (kElevationScale,                Between(1, 1))
  281. #define        (kHeightMapChaos,                Between(14, 17))
  282.                         
  283. #define        (kMinimumStartPositionToMapEdge    5)
  284. #define        (kOuterPushFromMapCenter        20)
  285. #define        (kInnerPushFromMapCenter         0)    
  286.  
  287. #define        (kConvergentSampleSize,            5) 
  288. #define        (kConvergentThreshold,            8) 
  289.                     
  290. //////////////////////////////////////////////////////////////////////
  291. // player definitions
  292. #define        (kMaxAngleBetweenTeamMembers,        60.0)
  293. #define        (kPlayerInnerRadius,            0.6)
  294. #define        (kPlayerOuterRadius,            0.8)
  295. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  296. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  297. #define        (kPlayerLandChaos,            0.8)
  298. #define        (kPlayerLandClumps,            Between(1, 1))
  299. #define        (kPlayerFlatChaos,            0.8)
  300. #define        (kPlayerFlatClumps,            Between(1, 1))
  301. #define        (kPlayerTreePercentage,            0.07)
  302.  
  303.  
  304. //////////////////////////////////////////////////////////////////////
  305. // inner neutral definitions
  306. #define        (kNeutralInnerRadius,            0.3)
  307. #define        (kNeutralOuterRadius,            0.3)
  308. #define        (kNeutralOptimalFactor,            0.7)
  309. #define        (kNumInnerNeutrals,                 Between(4, 4))
  310. #define        (kInnerNeutralPercentLand,        0.2)
  311. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  312. #define        (kInnerNeutralTreePercentage,          0.12)
  313. #define        (kInnerNeutralLandChaos,        0.8)
  314. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  315. #define        (kInnerNeutralFlatChaos,        0.8)
  316. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  317.  
  318. //////////////////////////////////////////////////////////////////////
  319. // outer neutral definitions
  320. #define        (kNumOuterNeutrals,            Between(6, 6))
  321. #define        (kOuterNeutralPercentLand,        0.47)
  322. #define        (kOuterNeutralPercentFlat,        Between(0.88, 0.88))
  323. #define        (kOuterNeutralTreePercentage,          0.13)
  324. #define        (kOuterNeutralLandChaos,        0.8)
  325. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  326. #define        (kOuterNeutralFlatChaos,        0.8)
  327. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  328.  
  329. //////////////////////////////////////////////////////////////////////
  330. // resource definitions
  331. #define        (kMaxResourceElevation,            3)
  332. #define        (kResourceToEdgeDistance,        2)
  333. #define        (kResourceToWaterDistance,        4)
  334.  
  335. #define        (kAnimalPerPlayer,            0)
  336. #define        (kAnimalPerNeutral,            0)
  337.  
  338. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  339.   #define  (kBerryPerPlayer,    1) 
  340.   #define  (kBerryPerNeutral,      5)
  341. #else
  342.   #define  (kBerryPerPlayer,    1)
  343.   #define  (kBerryPerNeutral,      0)
  344. #endif 
  345.  
  346. #define        (kFishPerPlayer,                0)
  347. #define        (kFishPerNeutral,                0)
  348.  
  349. #define        (kGoldPerPlayer,                1)
  350. #define        (kGoldPerNeutral,                8)
  351.  
  352. #define        (kOilPerPlayer,                0)
  353. #define        (kOilPerNeutral,                0)
  354.  
  355. #define        (kSteelPerPlayer,                1)
  356. #define        (kSteelPerNeutral,            8)
  357.  
  358. #define        (kStonePerPlayer,                1)
  359. #define        (kStonePerNeutral,            4)
  360.  
  361. #define        (kTreePerPlayer,                1)
  362. #define        (kTreePerNeutral,                0)
  363.  
  364.  
  365. //////////////////////////////////////////////////////////////////////
  366. // forest definitions
  367. #define        (kForestFreeRadius,                9.0)
  368. #define        (kForestsPerPlayer,                1)
  369. #define        (kForestChaosLevel,                0)
  370. #define        (kMaxClumpsPerForest,                  1)
  371.  
  372. #elif Is5Players
  373. //////////////////////////////////////////////////////////////////////
  374. // 5 PLAYERS...
  375. //////////////////////////////////////////////////////////////////////
  376.  
  377. //////////////////////////////////////////////////////////////////////
  378. // terrain definitions
  379.  
  380. #if        PERCENT(80)
  381.   #define        (kMaxIntElevation,            10)
  382. #else
  383.   #define        (kMaxIntElevation,            14)
  384. #endif 
  385.  
  386. #define        (kElevationScale,                Between(1, 1))
  387. #define        (kHeightMapChaos,                Between(11, 16))
  388.  
  389. #define        (kMinimumStartPositionToMapEdge    5)
  390. #define        (kOuterPushFromMapCenter        20)
  391. #define        (kInnerPushFromMapCenter         0)    
  392.  
  393. #define        (kConvergentSampleSize,            32) 
  394. #define        (kConvergentThreshold,            1)    
  395.                                             
  396. //////////////////////////////////////////////////////////////////////
  397. // player definitions
  398. #define        (kMaxAngleBetweenTeamMembers,        60.0)
  399. #define        (kPlayerInnerRadius,            0.6)
  400. #define        (kPlayerOuterRadius,            0.9)
  401. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  402. #define        (kPlayerPercentFlat,            Between(0.96, 0.96))
  403. #define        (kPlayerLandChaos,            0.8)
  404. #define        (kPlayerLandClumps,            Between(1, 1))
  405. #define        (kPlayerFlatChaos,            0.8)
  406. #define        (kPlayerFlatClumps,            Between(1, 1))
  407. #define        (kPlayerTreePercentage,            0.08)
  408.  
  409.  
  410. //////////////////////////////////////////////////////////////////////
  411. // inner neutral definitions
  412. #define        (kNeutralInnerRadius,            0.3)
  413. #define        (kNeutralOuterRadius,            0.3)
  414. #define        (kNeutralOptimalFactor,            0.7)
  415. #define        (kNumInnerNeutrals,                 Between(4, 4))
  416. #define        (kInnerNeutralPercentLand,        0.2)
  417. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  418. #define        (kInnerNeutralTreePercentage,          0.11)
  419. #define        (kInnerNeutralLandChaos,        0.8)
  420. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  421. #define        (kInnerNeutralFlatChaos,        0.8)
  422. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  423.  
  424.  
  425. //////////////////////////////////////////////////////////////////////
  426. // outer neutral definitions
  427. #define        (kNumOuterNeutrals,            Between(4, 4))
  428. #define        (kOuterNeutralPercentLand,        0.39)
  429. #define        (kOuterNeutralPercentFlat,        Between(0.86, 0.86))
  430. #define        (kOuterNeutralTreePercentage,          0.13)
  431. #define        (kOuterNeutralLandChaos,        0.8)
  432. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  433. #define        (kOuterNeutralFlatChaos,        0.8)
  434. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  435.  
  436. //////////////////////////////////////////////////////////////////////
  437. // resource definitions
  438. #define        (kMaxResourceElevation,            3)
  439. #define        (kResourceToEdgeDistance,        1)
  440. #define        (kResourceToWaterDistance,        4)
  441.  
  442. #define        (kAnimalPerPlayer,            0)
  443. #define        (kAnimalPerNeutral,            0)
  444.  
  445. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  446.   #define  (kBerryPerPlayer,    2)
  447. #else
  448.   #define  (kBerryPerPlayer,    1)
  449. #endif 
  450.  
  451. #define        (kBerryPerNeutral,            0)
  452.  
  453. #define        (kFishPerPlayer,                0)
  454. #define        (kFishPerNeutral,                0)
  455.  
  456. #define        (kGoldPerPlayer,                1)
  457. #define        (kGoldPerNeutral,                8)
  458.  
  459. #define        (kOilPerPlayer,                0)
  460. #define        (kOilPerNeutral,                0)
  461.  
  462. #define        (kSteelPerPlayer,                1)
  463. #define        (kSteelPerNeutral,            8)
  464.  
  465. #define        (kStonePerPlayer,                1)
  466. #define        (kStonePerNeutral,            5)
  467.  
  468. #define        (kTreePerPlayer,                1)
  469. #define        (kTreePerNeutral,                0)
  470.  
  471.  
  472. //////////////////////////////////////////////////////////////////////
  473. // forest definitions
  474. #define        (kForestFreeRadius,                9.0)
  475. #define        (kForestsPerPlayer,                1)
  476. #define        (kForestChaosLevel,                0)
  477. #define        (kMaxClumpsPerForest,                  1)
  478.  
  479.  
  480. #elif Is6Players
  481. //////////////////////////////////////////////////////////////////////
  482. // 6 PLAYERS...
  483. //////////////////////////////////////////////////////////////////////
  484.  
  485. //////////////////////////////////////////////////////////////////////
  486. // terrain definitions
  487.  
  488. #if        PERCENT(80)
  489.   #define        (kMaxIntElevation,            10)
  490. #else
  491.   #define        (kMaxIntElevation,            14)
  492. #endif 
  493.  
  494. #define        (kElevationScale,                Between(1, 1))
  495. #define        (kHeightMapChaos,                Between(11, 16))
  496.  
  497. #define        (kMinimumStartPositionToMapEdge    5)
  498. #define        (kOuterPushFromMapCenter        20)
  499. #define        (kInnerPushFromMapCenter         0)    
  500.  
  501. #define        (kConvergentSampleSize,            32) 
  502. #define        (kConvergentThreshold,            1) 
  503.                                             
  504. //////////////////////////////////////////////////////////////////////
  505. // player definitions
  506. #define        (kMaxAngleBetweenTeamMembers,        60.0)
  507. #define        (kPlayerInnerRadius,            0.6)
  508. #define        (kPlayerOuterRadius,            0.9)
  509. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  510. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  511. #define        (kPlayerLandChaos,            0.8)
  512. #define        (kPlayerLandClumps,            Between(1, 1))
  513. #define        (kPlayerFlatChaos,            0.8)
  514. #define        (kPlayerFlatClumps,            Between(1, 1))
  515. #define        (kPlayerTreePercentage,            0.09)
  516.  
  517.  
  518. //////////////////////////////////////////////////////////////////////
  519. // inner neutral definitions
  520. #define        (kNeutralInnerRadius,            0.3)
  521. #define        (kNeutralOuterRadius,            0.3)
  522. #define        (kNeutralOptimalFactor,            0.7)
  523. #define        (kNumInnerNeutrals,                 Between(4, 4))
  524. #define        (kInnerNeutralPercentLand,        0.18)
  525. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  526. #define        (kInnerNeutralTreePercentage,          0.11)
  527. #define        (kInnerNeutralLandChaos,        0.8)
  528. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  529. #define        (kInnerNeutralFlatChaos,        0.8)
  530. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  531.  
  532. //////////////////////////////////////////////////////////////////////
  533. // outer neutral definitions
  534. #define        (kNumOuterNeutrals,            Between(2, 2))
  535. #define        (kOuterNeutralPercentLand,        0.33)
  536. #define        (kOuterNeutralPercentFlat,        Between(0.84, 0.84))
  537. #define        (kOuterNeutralTreePercentage,          0.14)
  538. #define        (kOuterNeutralLandChaos,        0.8)
  539. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  540. #define        (kOuterNeutralFlatChaos,        0.8)
  541. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  542.  
  543. //////////////////////////////////////////////////////////////////////
  544. // resource definitions
  545. #define        (kMaxResourceElevation,            3)
  546. #define        (kResourceToEdgeDistance,        1)
  547. #define        (kResourceToWaterDistance,        4)
  548.  
  549. #define        (kAnimalPerPlayer,            0)
  550. #define        (kAnimalPerNeutral,            0)
  551.  
  552. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  553.   #define  (kBerryPerPlayer,    2)
  554. #else
  555.   #define  (kBerryPerPlayer,    1)
  556. #endif 
  557.  
  558. #define        (kBerryPerNeutral,            0)
  559.  
  560. #define        (kFishPerPlayer,                0)
  561. #define        (kFishPerNeutral,                0)
  562.  
  563. #define        (kGoldPerPlayer,                2)
  564. #define        (kGoldPerNeutral,                2)
  565.  
  566. #define        (kOilPerPlayer,                0)
  567. #define        (kOilPerNeutral,                0)
  568.  
  569. #define        (kSteelPerPlayer,                2)
  570. #define        (kSteelPerNeutral,            2)
  571.  
  572. #define        (kStonePerPlayer,                1)
  573. #define        (kStonePerNeutral,            6)
  574.  
  575. #define        (kTreePerPlayer,                1)
  576. #define        (kTreePerNeutral,                0)
  577.  
  578.  
  579. //////////////////////////////////////////////////////////////////////
  580. // forest definitions
  581. #define        (kForestFreeRadius,                8.0)
  582. #define        (kForestsPerPlayer,                1)
  583. #define        (kForestChaosLevel,                0)
  584. #define        (kMaxClumpsPerForest,                  2)
  585.  
  586.  
  587. #elif Is7Players
  588. //////////////////////////////////////////////////////////////////////
  589. // 7 PLAYERS...
  590. //////////////////////////////////////////////////////////////////////
  591.  
  592. //////////////////////////////////////////////////////////////////////
  593. // terrain definitions
  594.  
  595. #if        PERCENT(80)
  596.   #define        (kMaxIntElevation,            9)
  597. #else
  598.   #define        (kMaxIntElevation,            15)
  599. #endif 
  600.  
  601. #define        (kElevationScale,                Between(1, 1))
  602. #define        (kHeightMapChaos,                Between(10, 18))
  603.  
  604. #define        (kMinimumStartPositionToMapEdge    5)
  605. #define        (kOuterPushFromMapCenter        20)
  606. #define        (kInnerPushFromMapCenter         0)    
  607.  
  608. #define        (kConvergentSampleSize,            32) 
  609. #define        (kConvergentThreshold,            1) 
  610.                                             
  611. //////////////////////////////////////////////////////////////////////
  612. // player definitions
  613. #define        (kMaxAngleBetweenTeamMembers,          60.0)
  614. #define        (kPlayerInnerRadius,            0.6)
  615. #define        (kPlayerOuterRadius,            0.9)
  616. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  617. #define        (kPlayerPercentFlat,            Between(0.92, 0.92))
  618. #define        (kPlayerLandChaos,            0.8)
  619. #define        (kPlayerLandClumps,            Between(1, 1))
  620. #define        (kPlayerFlatChaos,            0.8)
  621. #define        (kPlayerFlatClumps,            Between(1, 1))
  622. #define        (kPlayerTreePercentage,            0.1)
  623.  
  624.  
  625. //////////////////////////////////////////////////////////////////////
  626. // inner neutral definitions
  627. #define        (kNeutralInnerRadius,            0.3)
  628. #define        (kNeutralOuterRadius,            0.3)
  629. #define        (kNeutralOptimalFactor,            0.7)
  630. #define        (kNumInnerNeutrals,                 Between(4, 4))
  631. #define        (kInnerNeutralPercentLand,        0.18)
  632. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  633. #define        (kInnerNeutralTreePercentage,          0.10)
  634. #define        (kInnerNeutralLandChaos,        0.8)
  635. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  636. #define        (kInnerNeutralFlatChaos,        0.8)
  637. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  638.  
  639. //////////////////////////////////////////////////////////////////////
  640. // outer neutral definitions
  641. #define        (kNumOuterNeutrals,            Between(0, 0))
  642. #define        (kOuterNeutralPercentLand,        0.26)
  643. #define        (kOuterNeutralPercentFlat,        Between(0.82, 0.82))
  644. #define        (kOuterNeutralTreePercentage,          0.14)
  645. #define        (kOuterNeutralLandChaos,        0.8)
  646. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  647. #define        (kOuterNeutralFlatChaos,        0.8)
  648. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  649.  
  650. //////////////////////////////////////////////////////////////////////
  651. // resource definitions
  652. #define        (kMaxResourceElevation,            3)
  653. #define        (kResourceToEdgeDistance,        1)
  654. #define        (kResourceToWaterDistance,        4)
  655.  
  656. #define        (kAnimalPerPlayer,            0)
  657. #define        (kAnimalPerNeutral,            0)
  658.  
  659. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  660.   #define  (kBerryPerPlayer,    2)
  661. #else
  662.   #define  (kBerryPerPlayer,    1)
  663. #endif 
  664.  
  665. #define        (kBerryPerNeutral,            0)
  666.  
  667. #define        (kFishPerPlayer,                0)
  668. #define        (kFishPerNeutral,                0)
  669.  
  670. #define        (kGoldPerPlayer,                2)
  671. #define        (kGoldPerNeutral,                1)
  672.  
  673. #define        (kOilPerPlayer,                0)
  674. #define        (kOilPerNeutral,                0)
  675.  
  676. #define        (kSteelPerPlayer,                2)
  677. #define        (kSteelPerNeutral,            1)
  678.  
  679. #define        (kStonePerPlayer,                1)
  680. #define        (kStonePerNeutral,            6)
  681.  
  682. #define        (kTreePerPlayer,                1)
  683. #define        (kTreePerNeutral,                0)
  684.  
  685.  
  686. //////////////////////////////////////////////////////////////////////
  687. // forest definitions
  688. #define        (kForestFreeRadius,                8.0)
  689. #define        (kForestsPerPlayer,                1)
  690. #define        (kForestChaosLevel,                0)
  691. #define        (kMaxClumpsPerForest,                  1)
  692.  
  693. #elif Is8Players
  694. //////////////////////////////////////////////////////////////////////
  695. // 8 PLAYERS...
  696. //////////////////////////////////////////////////////////////////////
  697.  
  698. //////////////////////////////////////////////////////////////////////
  699. // terrain definitions
  700.  
  701. #if        PERCENT(80)
  702.   #define        (kMaxIntElevation,            9)
  703. #else
  704.   #define        (kMaxIntElevation,            15)
  705. #endif 
  706.  
  707. #define        (kElevationScale,                Between(1, 1))
  708. #define        (kHeightMapChaos,                Between(10, 18))
  709.  
  710. #define        (kMinimumStartPositionToMapEdge    5)
  711. #define        (kOuterPushFromMapCenter        20)
  712. #define        (kInnerPushFromMapCenter         0)    
  713.  
  714. #define        (kConvergentSampleSize,            32) 
  715. #define        (kConvergentThreshold,            1) 
  716.                                             
  717. //////////////////////////////////////////////////////////////////////
  718. // player definitions
  719. #define        (kMaxAngleBetweenTeamMembers,        60.0)
  720. #define        (kPlayerInnerRadius,            0.6)
  721. #define        (kPlayerOuterRadius,            0.9)
  722. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  723. #define        (kPlayerPercentFlat,            Between(.9, .9))
  724. #define        (kPlayerLandChaos,            0.8)
  725. #define        (kPlayerLandClumps,            Between(1, 1))
  726. #define        (kPlayerFlatChaos,            0.8)
  727. #define        (kPlayerFlatClumps,            Between(1, 1))
  728. #define        (kPlayerTreePercentage,            0.09)
  729.  
  730. //////////////////////////////////////////////////////////////////////
  731. // inner neutral definitions
  732. #define        (kNeutralInnerRadius,            0.3)
  733. #define        (kNeutralOuterRadius,            0.3)
  734. #define        (kNeutralOptimalFactor,            0.7)
  735. #define        (kNumInnerNeutrals,                 Between(4, 4))
  736. #define        (kInnerNeutralPercentLand,        0.18)
  737. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  738. #define        (kInnerNeutralTreePercentage,          0.10)
  739. #define        (kInnerNeutralLandChaos,        0.8)
  740. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  741. #define        (kInnerNeutralFlatChaos,        0.8)
  742. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  743.  
  744. //////////////////////////////////////////////////////////////////////
  745. // outer neutral definitions
  746. #define        (kNumOuterNeutrals,            Between(0, 0))
  747. #define        (kOuterNeutralPercentLand,        0.2)
  748. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  749. #define        (kOuterNeutralTreePercentage,          0.15)
  750. #define        (kOuterNeutralLandChaos,        0.8)
  751. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  752. #define        (kOuterNeutralFlatChaos,        0.8)
  753. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  754.  
  755. //////////////////////////////////////////////////////////////////////
  756. // resource definitions
  757. #define        (kMaxResourceElevation,            3)
  758. #define        (kResourceToEdgeDistance,        1)
  759. #define        (kResourceToWaterDistance,        4)
  760.  
  761. #define        (kAnimalPerPlayer,            0)
  762. #define        (kAnimalPerNeutral,            0)
  763.  
  764. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  765.   #define  (kBerryPerPlayer,    2)
  766. #else
  767.   #define  (kBerryPerPlayer,    1)
  768. #endif 
  769.  
  770. #define        (kBerryPerNeutral,            0)
  771.  
  772. #define        (kFishPerPlayer,                0)
  773. #define        (kFishPerNeutral,                0)
  774.  
  775. #define        (kGoldPerPlayer,                2)
  776. #define        (kGoldPerNeutral,                0)
  777.  
  778. #define        (kOilPerPlayer,                0)
  779. #define        (kOilPerNeutral,                0)
  780.  
  781. #define        (kSteelPerPlayer,                2)
  782. #define        (kSteelPerNeutral,            0)
  783.  
  784. #define        (kStonePerPlayer,                1)
  785. #define        (kStonePerNeutral,            5)
  786.  
  787. #define        (kTreePerPlayer,                1)
  788. #define        (kTreePerNeutral,                0)
  789.  
  790.  
  791. //////////////////////////////////////////////////////////////////////
  792. // forest definitions
  793. #define        (kForestFreeRadius,                8.0)
  794. #define        (kForestsPerPlayer,                1)
  795. #define        (kForestChaosLevel,                0)
  796. #define        (kMaxClumpsPerForest,                  1)
  797.  
  798. #elif Is9Players
  799. //////////////////////////////////////////////////////////////////////
  800. // 9 PLAYERS...
  801. //////////////////////////////////////////////////////////////////////
  802.  
  803. //////////////////////////////////////////////////////////////////////
  804. // terrain definitions
  805. #define        (kMaxIntElevation,            15)
  806. #define        (kElevationScale,                Between(1, 1))
  807. #define        (kHeightMapChaos,                Between(20, 60))
  808.  
  809. #define        (kMinimumStartPositionToMapEdge    2)
  810. #define        (kOuterPushFromMapCenter        20)
  811. #define        (kInnerPushFromMapCenter         0)    
  812.  
  813. #define        (kConvergentSampleSize,            4) 
  814. #define        (kConvergentThreshold,            10) 
  815.                                             
  816. //////////////////////////////////////////////////////////////////////
  817. // player definitions
  818. #define        (kMaxAngleBetweenTeamMembers,        60.0)
  819. #define        (kPlayerInnerRadius,            0.6)
  820. #define        (kPlayerOuterRadius,            0.95)
  821. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  822. #define        (kPlayerPercentFlat,            Between(.9, .9))
  823. #define        (kPlayerLandChaos,            0.8)
  824. #define        (kPlayerLandClumps,            Between(2, 2))
  825. #define        (kPlayerFlatChaos,            0.8)
  826. #define        (kPlayerFlatClumps,            Between(1, 2))
  827. #define        (kPlayerTreePercentage,            0.08)
  828.  
  829. //////////////////////////////////////////////////////////////////////
  830. // inner neutral definitions
  831. #define        (kNeutralInnerRadius,            0.3)
  832. #define        (kNeutralOuterRadius,            0.4)
  833. #define        (kNeutralOptimalFactor,            0.7)
  834. #define        (kNumInnerNeutrals,                 Between(10, 10))
  835. #define        (kInnerNeutralPercentLand,        0.19)
  836. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  837. #define        (kInnerNeutralTreePercentage,          0.15)
  838. #define        (kInnerNeutralLandChaos,        0.8)
  839. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  840. #define        (kInnerNeutralFlatChaos,        0.8)
  841. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  842.  
  843. //////////////////////////////////////////////////////////////////////
  844. // outer neutral definitions
  845. #define        (kNumOuterNeutrals,            Between(10, 10))
  846. #define        (kOuterNeutralPercentLand,        0.2)
  847. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  848. #define        (kOuterNeutralTreePercentage,          0.25)
  849. #define        (kOuterNeutralLandChaos,        0.8)
  850. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  851. #define        (kOuterNeutralFlatChaos,        0.8)
  852. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  853.  
  854. //////////////////////////////////////////////////////////////////////
  855. // resource definitions
  856. #define        (kMaxResourceElevation,            4)
  857. #define        (kResourceToEdgeDistance,        2)
  858. #define        (kResourceToWaterDistance,        4)
  859.  
  860. #define        (kAnimalPerPlayer,            0)
  861. #define        (kAnimalPerNeutral,            0)
  862.  
  863. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  864.   #define  (kBerryPerPlayer,    2)
  865. #else
  866.   #define  (kBerryPerPlayer,    1)
  867. #endif 
  868.  
  869. #define        (kBerryPerNeutral,            0)
  870.  
  871. #define        (kFishPerPlayer,                0)
  872. #define        (kFishPerNeutral,                0)
  873.  
  874. #define        (kGoldPerPlayer,                2)
  875. #define        (kGoldPerNeutral,                2)
  876.  
  877. #define        (kOilPerPlayer,                0)
  878. #define        (kOilPerNeutral,                0)
  879.  
  880. #define        (kSteelPerPlayer,                2)
  881. #define        (kSteelPerNeutral,            2)
  882.  
  883. #define        (kStonePerPlayer,                1)
  884. #define        (kStonePerNeutral,            5)
  885.  
  886. #define        (kTreePerPlayer,                0)
  887. #define        (kTreePerNeutral,                0)
  888.  
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891. // forest definitions
  892. #define        (kForestFreeRadius,                7.0)
  893. #define        (kForestsPerPlayer,                1 )
  894. #define        (kForestChaosLevel,                1)
  895. #define        (kMaxClumpsPerForest,                  2)
  896.  
  897. #elif Is10Players
  898. //////////////////////////////////////////////////////////////////////
  899. // 10 PLAYERS...
  900. //////////////////////////////////////////////////////////////////////
  901.  
  902. //////////////////////////////////////////////////////////////////////
  903. // terrain definitions
  904. #define        (kMaxIntElevation,            15)
  905. #define        (kElevationScale,                Between(1, 1))
  906. #define        (kHeightMapChaos,                Between(20, 60))
  907.  
  908. #define        (kMinimumStartPositionToMapEdge    2)
  909. #define        (kOuterPushFromMapCenter        20)
  910. #define        (kInnerPushFromMapCenter         0)    
  911.                                             
  912. //////////////////////////////////////////////////////////////////////
  913. // player definitions
  914. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  915. #define        (kPlayerInnerRadius,            0.6)
  916. #define        (kPlayerOuterRadius,            0.95)
  917. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  918. #define        (kPlayerPercentFlat,            Between(.9, .9))
  919. #define        (kPlayerLandChaos,            0.8)
  920. #define        (kPlayerLandClumps,            Between(2, 2))
  921. #define        (kPlayerFlatChaos,            0.8)
  922. #define        (kPlayerFlatClumps,            Between(1, 2))
  923. #define        (kPlayerTreePercentage,            0.08)
  924.  
  925. //////////////////////////////////////////////////////////////////////
  926. // inner neutral definitions
  927. #define        (kNeutralInnerRadius,            0.3)
  928. #define        (kNeutralOuterRadius,            0.4)
  929. #define        (kNeutralOptimalFactor,            0.7)
  930. #define        (kNumInnerNeutrals,                 Between(10, 10))
  931. #define        (kInnerNeutralPercentLand,        0.19)
  932. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  933. #define        (kInnerNeutralTreePercentage,          0.15)
  934. #define        (kInnerNeutralLandChaos,        0.8)
  935. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  936. #define        (kInnerNeutralFlatChaos,        0.8)
  937. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  938.  
  939. //////////////////////////////////////////////////////////////////////
  940. // outer neutral definitions
  941. #define        (kNumOuterNeutrals,            Between(10, 10))
  942. #define        (kOuterNeutralPercentLand,        0.2)
  943. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  944. #define        (kOuterNeutralTreePercentage,          0.25)
  945. #define        (kOuterNeutralLandChaos,        0.8)
  946. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  947. #define        (kOuterNeutralFlatChaos,        0.8)
  948. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  949.  
  950. //////////////////////////////////////////////////////////////////////
  951. // resource definitions
  952. #define        (kMaxResourceElevation,            4)
  953. #define        (kResourceToEdgeDistance,        2)
  954. #define        (kResourceToWaterDistance,        4)
  955.  
  956. #define        (kAnimalPerPlayer,            0)
  957. #define        (kAnimalPerNeutral,            0)
  958.  
  959. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  960.   #define  (kBerryPerPlayer,    2)
  961. #else
  962.   #define  (kBerryPerPlayer,    1)
  963. #endif 
  964.  
  965. #define        (kBerryPerNeutral,            0)
  966.  
  967. #define        (kFishPerPlayer,                0)
  968. #define        (kFishPerNeutral,                0)
  969.  
  970. #define        (kGoldPerPlayer,                2)
  971. #define        (kGoldPerNeutral,                2)
  972.  
  973. #define        (kOilPerPlayer,                0)
  974. #define        (kOilPerNeutral,                0)
  975.  
  976. #define        (kSteelPerPlayer,                2)
  977. #define        (kSteelPerNeutral,            2)
  978.  
  979. #define        (kStonePerPlayer,                1)
  980. #define        (kStonePerNeutral,            5)
  981.  
  982. #define        (kTreePerPlayer,                0)
  983. #define        (kTreePerNeutral,                0)
  984.  
  985.  
  986. //////////////////////////////////////////////////////////////////////
  987. // forest definitions
  988. #define        (kForestFreeRadius,                7.0)
  989. #define        (kForestsPerPlayer,                1 )
  990. #define        (kForestChaosLevel,                1)
  991. #define        (kMaxClumpsPerForest,                  2)
  992.  
  993.  
  994. #elif Is11Players
  995. //////////////////////////////////////////////////////////////////////
  996. // 11 PLAYERS...
  997. //////////////////////////////////////////////////////////////////////
  998.  
  999. //////////////////////////////////////////////////////////////////////
  1000. // terrain definitions
  1001. #define        (kMaxIntElevation,            15)
  1002. #define        (kElevationScale,                Between(1, 1))
  1003. #define        (kHeightMapChaos,                Between(20, 60))
  1004.  
  1005. #define        (kMinimumStartPositionToMapEdge    2)
  1006. #define        (kOuterPushFromMapCenter        20)
  1007. #define        (kInnerPushFromMapCenter         0)    
  1008.                                             
  1009. //////////////////////////////////////////////////////////////////////
  1010. // player definitions
  1011. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1012. #define        (kPlayerInnerRadius,            0.6)
  1013. #define        (kPlayerOuterRadius,            0.95)
  1014. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1015. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1016. #define        (kPlayerLandChaos,            0.8)
  1017. #define        (kPlayerLandClumps,            Between(2, 2))
  1018. #define        (kPlayerFlatChaos,            0.8)
  1019. #define        (kPlayerFlatClumps,            Between(1, 2))
  1020. #define        (kPlayerTreePercentage,            0.08)
  1021.  
  1022. //////////////////////////////////////////////////////////////////////
  1023. // inner neutral definitions
  1024. #define        (kNeutralInnerRadius,            0.3)
  1025. #define        (kNeutralOuterRadius,            0.4)
  1026. #define        (kNeutralOptimalFactor,            0.7)
  1027. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1028. #define        (kInnerNeutralPercentLand,        0.19)
  1029. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1030. #define        (kInnerNeutralTreePercentage,          0.15)
  1031. #define        (kInnerNeutralLandChaos,        0.8)
  1032. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1033. #define        (kInnerNeutralFlatChaos,        0.8)
  1034. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1035.  
  1036. //////////////////////////////////////////////////////////////////////
  1037. // outer neutral definitions
  1038. #define        (kNumOuterNeutrals,            Between(10, 10))
  1039. #define        (kOuterNeutralPercentLand,        0.2)
  1040. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1041. #define        (kOuterNeutralTreePercentage,          0.25)
  1042. #define        (kOuterNeutralLandChaos,        0.8)
  1043. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1044. #define        (kOuterNeutralFlatChaos,        0.8)
  1045. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1046.  
  1047. //////////////////////////////////////////////////////////////////////
  1048. // resource definitions
  1049. #define        (kMaxResourceElevation,            4)
  1050. #define        (kResourceToEdgeDistance,        2)
  1051. #define        (kResourceToWaterDistance,        4)
  1052.  
  1053. #define        (kAnimalPerPlayer,            0)
  1054. #define        (kAnimalPerNeutral,            0)
  1055.  
  1056. #define        (kBerryPerPlayer,                1)
  1057. #define        (kBerryPerNeutral,            0)
  1058.  
  1059. #define        (kFishPerPlayer,                0)
  1060. #define        (kFishPerNeutral,                0)
  1061.  
  1062. #define        (kGoldPerPlayer,                2)
  1063. #define        (kGoldPerNeutral,                2)
  1064.  
  1065. #define        (kOilPerPlayer,                0)
  1066. #define        (kOilPerNeutral,                0)
  1067.  
  1068. #define        (kSteelPerPlayer,                2)
  1069. #define        (kSteelPerNeutral,            2)
  1070.  
  1071. #define        (kStonePerPlayer,                1)
  1072. #define        (kStonePerNeutral,            5)
  1073.  
  1074. #define        (kTreePerPlayer,                0)
  1075. #define        (kTreePerNeutral,                0)
  1076.  
  1077.  
  1078. //////////////////////////////////////////////////////////////////////
  1079. // forest definitions
  1080. #define        (kForestFreeRadius,                7.0)
  1081. #define        (kForestsPerPlayer,                1 )
  1082. #define        (kForestChaosLevel,                1)
  1083. #define        (kMaxClumpsPerForest,                  2)
  1084.  
  1085.  
  1086. #elif Is12Players
  1087. //////////////////////////////////////////////////////////////////////
  1088. // 12 PLAYERS...
  1089. //////////////////////////////////////////////////////////////////////
  1090.  
  1091. //////////////////////////////////////////////////////////////////////
  1092. // terrain definitions
  1093. #define        (kMaxIntElevation,            15)
  1094. #define        (kElevationScale,                Between(1, 1))
  1095. #define        (kHeightMapChaos,                Between(20, 60))
  1096.  
  1097. #define        (kMinimumStartPositionToMapEdge    2)
  1098. #define        (kOuterPushFromMapCenter        20)
  1099. #define        (kInnerPushFromMapCenter         0)    
  1100.                                             
  1101. //////////////////////////////////////////////////////////////////////
  1102. // player definitions
  1103. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1104. #define        (kPlayerInnerRadius,            0.6)
  1105. #define        (kPlayerOuterRadius,            0.95)
  1106. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1107. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1108. #define        (kPlayerLandChaos,            0.8)
  1109. #define        (kPlayerLandClumps,            Between(2, 2))
  1110. #define        (kPlayerFlatChaos,            0.8)
  1111. #define        (kPlayerFlatClumps,            Between(1, 2))
  1112. #define        (kPlayerTreePercentage,            0.08)
  1113.  
  1114. //////////////////////////////////////////////////////////////////////
  1115. // inner neutral definitions
  1116. #define        (kNeutralInnerRadius,            0.3)
  1117. #define        (kNeutralOuterRadius,            0.4)
  1118. #define        (kNeutralOptimalFactor,            0.7)
  1119. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1120. #define        (kInnerNeutralPercentLand,        0.19)
  1121. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1122. #define        (kInnerNeutralTreePercentage,          0.15)
  1123. #define        (kInnerNeutralLandChaos,        0.8)
  1124. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1125. #define        (kInnerNeutralFlatChaos,        0.8)
  1126. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1127.  
  1128. //////////////////////////////////////////////////////////////////////
  1129. // outer neutral definitions
  1130. #define        (kNumOuterNeutrals,            Between(10, 10))
  1131. #define        (kOuterNeutralPercentLand,        0.2)
  1132. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1133. #define        (kOuterNeutralTreePercentage,          0.25)
  1134. #define        (kOuterNeutralLandChaos,        0.8)
  1135. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1136. #define        (kOuterNeutralFlatChaos,        0.8)
  1137. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1138.  
  1139. //////////////////////////////////////////////////////////////////////
  1140. // resource definitions
  1141. #define        (kMaxResourceElevation,            4)
  1142. #define        (kResourceToEdgeDistance,        2)
  1143. #define        (kResourceToWaterDistance,        4)
  1144.  
  1145. #define        (kAnimalPerPlayer,            0)
  1146. #define        (kAnimalPerNeutral,            0)
  1147.  
  1148. #define        (kBerryPerPlayer,                1)
  1149. #define        (kBerryPerNeutral,            0)
  1150.  
  1151. #define        (kFishPerPlayer,                0)
  1152. #define        (kFishPerNeutral,                0)
  1153.  
  1154. #define        (kGoldPerPlayer,                2)
  1155. #define        (kGoldPerNeutral,                2)
  1156.  
  1157. #define        (kOilPerPlayer,                0)
  1158. #define        (kOilPerNeutral,                0)
  1159.  
  1160. #define        (kSteelPerPlayer,                2)
  1161. #define        (kSteelPerNeutral,            2)
  1162.  
  1163. #define        (kStonePerPlayer,                1)
  1164. #define        (kStonePerNeutral,            5)
  1165.  
  1166. #define        (kTreePerPlayer,                0)
  1167. #define        (kTreePerNeutral,                0)
  1168.  
  1169.  
  1170. //////////////////////////////////////////////////////////////////////
  1171. // forest definitions
  1172. #define        (kForestFreeRadius,                7.0)
  1173. #define        (kForestsPerPlayer,                1 )
  1174. #define        (kForestChaosLevel,                1)
  1175. #define        (kMaxClumpsPerForest,                  2)
  1176.  
  1177. #elif Is13Players
  1178. //////////////////////////////////////////////////////////////////////
  1179. // 13 PLAYERS...
  1180. //////////////////////////////////////////////////////////////////////
  1181.  
  1182. //////////////////////////////////////////////////////////////////////
  1183. // terrain definitions
  1184. #define        (kMaxIntElevation,            15)
  1185. #define        (kElevationScale,                Between(1, 1))
  1186. #define        (kHeightMapChaos,                Between(20, 60))
  1187.  
  1188. #define        (kMinimumStartPositionToMapEdge    2)
  1189. #define        (kOuterPushFromMapCenter        20)
  1190. #define        (kInnerPushFromMapCenter         0)    
  1191.                                             
  1192. //////////////////////////////////////////////////////////////////////
  1193. // player definitions
  1194. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1195. #define        (kPlayerInnerRadius,            0.6)
  1196. #define        (kPlayerOuterRadius,            0.95)
  1197. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1198. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1199. #define        (kPlayerLandChaos,            0.8)
  1200. #define        (kPlayerLandClumps,            Between(2, 2))
  1201. #define        (kPlayerFlatChaos,            0.8)
  1202. #define        (kPlayerFlatClumps,            Between(1, 2))
  1203. #define        (kPlayerTreePercentage,            0.08)
  1204.  
  1205. //////////////////////////////////////////////////////////////////////
  1206. // inner neutral definitions
  1207. #define        (kNeutralInnerRadius,            0.3)
  1208. #define        (kNeutralOuterRadius,            0.4)
  1209. #define        (kNeutralOptimalFactor,            0.7)
  1210. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1211. #define        (kInnerNeutralPercentLand,        0.19)
  1212. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1213. #define        (kInnerNeutralTreePercentage,          0.15)
  1214. #define        (kInnerNeutralLandChaos,        0.8)
  1215. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1216. #define        (kInnerNeutralFlatChaos,        0.8)
  1217. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1218.  
  1219. //////////////////////////////////////////////////////////////////////
  1220. // outer neutral definitions
  1221. #define        (kNumOuterNeutrals,            Between(10, 10))
  1222. #define        (kOuterNeutralPercentLand,        0.2)
  1223. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1224. #define        (kOuterNeutralTreePercentage,          0.25)
  1225. #define        (kOuterNeutralLandChaos,        0.8)
  1226. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1227. #define        (kOuterNeutralFlatChaos,        0.8)
  1228. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1229.  
  1230. //////////////////////////////////////////////////////////////////////
  1231. // resource definitions
  1232. #define        (kMaxResourceElevation,            4)
  1233. #define        (kResourceToEdgeDistance,        2)
  1234. #define        (kResourceToWaterDistance,        4)
  1235.  
  1236. #define        (kAnimalPerPlayer,            0)
  1237. #define        (kAnimalPerNeutral,            0)
  1238.  
  1239. #define        (kBerryPerPlayer,                1)
  1240. #define        (kBerryPerNeutral,            0)
  1241.  
  1242. #define        (kFishPerPlayer,                0)
  1243. #define        (kFishPerNeutral,                0)
  1244.  
  1245. #define        (kGoldPerPlayer,                2)
  1246. #define        (kGoldPerNeutral,                2)
  1247.  
  1248. #define        (kOilPerPlayer,                0)
  1249. #define        (kOilPerNeutral,                0)
  1250.  
  1251. #define        (kSteelPerPlayer,                2)
  1252. #define        (kSteelPerNeutral,            2)
  1253.  
  1254. #define        (kStonePerPlayer,                1)
  1255. #define        (kStonePerNeutral,            5)
  1256.  
  1257. #define        (kTreePerPlayer,                0)
  1258. #define        (kTreePerNeutral,                0)
  1259.  
  1260.  
  1261. //////////////////////////////////////////////////////////////////////
  1262. // forest definitions
  1263. #define        (kForestFreeRadius,                7.0)
  1264. #define        (kForestsPerPlayer,                1 )
  1265. #define        (kForestChaosLevel,                1)
  1266. #define        (kMaxClumpsPerForest,                  2)
  1267.  
  1268.  
  1269. #elif Is14Players
  1270. //////////////////////////////////////////////////////////////////////
  1271. // 14 PLAYERS...
  1272. //////////////////////////////////////////////////////////////////////
  1273.  
  1274. //////////////////////////////////////////////////////////////////////
  1275. // terrain definitions
  1276. #define        (kMaxIntElevation,            15)
  1277. #define        (kElevationScale,                Between(1, 1))
  1278. #define        (kHeightMapChaos,                Between(20, 60))
  1279.  
  1280. #define        (kMinimumStartPositionToMapEdge    2)
  1281. #define        (kOuterPushFromMapCenter        20)
  1282. #define        (kInnerPushFromMapCenter         0)    
  1283.                                             
  1284. //////////////////////////////////////////////////////////////////////
  1285. // player definitions
  1286. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1287. #define        (kPlayerInnerRadius,            0.6)
  1288. #define        (kPlayerOuterRadius,            0.95)
  1289. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1290. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1291. #define        (kPlayerLandChaos,            0.8)
  1292. #define        (kPlayerLandClumps,            Between(2, 2))
  1293. #define        (kPlayerFlatChaos,            0.8)
  1294. #define        (kPlayerFlatClumps,            Between(1, 2))
  1295. #define        (kPlayerTreePercentage,            0.08)
  1296.  
  1297. //////////////////////////////////////////////////////////////////////
  1298. // inner neutral definitions
  1299. #define        (kNeutralInnerRadius,            0.3)
  1300. #define        (kNeutralOuterRadius,            0.4)
  1301. #define        (kNeutralOptimalFactor,            0.7)
  1302. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1303. #define        (kInnerNeutralPercentLand,        0.19)
  1304. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1305. #define        (kInnerNeutralTreePercentage,          0.15)
  1306. #define        (kInnerNeutralLandChaos,        0.8)
  1307. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1308. #define        (kInnerNeutralFlatChaos,        0.8)
  1309. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1310.  
  1311. //////////////////////////////////////////////////////////////////////
  1312. // outer neutral definitions
  1313. #define        (kNumOuterNeutrals,            Between(10, 10))
  1314. #define        (kOuterNeutralPercentLand,        0.2)
  1315. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1316. #define        (kOuterNeutralTreePercentage,          0.25)
  1317. #define        (kOuterNeutralLandChaos,        0.8)
  1318. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1319. #define        (kOuterNeutralFlatChaos,        0.8)
  1320. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1321.  
  1322. //////////////////////////////////////////////////////////////////////
  1323. // resource definitions
  1324. #define        (kMaxResourceElevation,            4)
  1325. #define        (kResourceToEdgeDistance,        2)
  1326. #define        (kResourceToWaterDistance,        4)
  1327.  
  1328. #define        (kAnimalPerPlayer,            0)
  1329. #define        (kAnimalPerNeutral,            0)
  1330.  
  1331. #define        (kBerryPerPlayer,                1)
  1332. #define        (kBerryPerNeutral,            0)
  1333.  
  1334. #define        (kFishPerPlayer,                0)
  1335. #define        (kFishPerNeutral,                0)
  1336.  
  1337. #define        (kGoldPerPlayer,                2)
  1338. #define        (kGoldPerNeutral,                2)
  1339.  
  1340. #define        (kOilPerPlayer,                0)
  1341. #define        (kOilPerNeutral,                0)
  1342.  
  1343. #define        (kSteelPerPlayer,                2)
  1344. #define        (kSteelPerNeutral,            2)
  1345.  
  1346. #define        (kStonePerPlayer,                1)
  1347. #define        (kStonePerNeutral,            5)
  1348.  
  1349. #define        (kTreePerPlayer,                0)
  1350. #define        (kTreePerNeutral,                0)
  1351.  
  1352.  
  1353. //////////////////////////////////////////////////////////////////////
  1354. // forest definitions
  1355. #define        (kForestFreeRadius,                7.0)
  1356. #define        (kForestsPerPlayer,                1 )
  1357. #define        (kForestChaosLevel,                1)
  1358. #define        (kMaxClumpsPerForest,                  2)
  1359.  
  1360.  
  1361. #elif Is15Players
  1362. //////////////////////////////////////////////////////////////////////
  1363. // 15 PLAYERS...
  1364. //////////////////////////////////////////////////////////////////////
  1365.  
  1366. //////////////////////////////////////////////////////////////////////
  1367. // terrain definitions
  1368. #define        (kMaxIntElevation,            15)
  1369. #define        (kElevationScale,                Between(1, 1))
  1370. #define        (kHeightMapChaos,                Between(20, 60))
  1371.  
  1372. #define        (kMinimumStartPositionToMapEdge    2)
  1373. #define        (kOuterPushFromMapCenter        20)
  1374. #define        (kInnerPushFromMapCenter         0)    
  1375.                                             
  1376. //////////////////////////////////////////////////////////////////////
  1377. // player definitions
  1378. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1379. #define        (kPlayerInnerRadius,            0.6)
  1380. #define        (kPlayerOuterRadius,            0.95)
  1381. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1382. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1383. #define        (kPlayerLandChaos,            0.8)
  1384. #define        (kPlayerLandClumps,            Between(2, 2))
  1385. #define        (kPlayerFlatChaos,            0.8)
  1386. #define        (kPlayerFlatClumps,            Between(1, 2))
  1387. #define        (kPlayerTreePercentage,            0.08)
  1388.  
  1389. //////////////////////////////////////////////////////////////////////
  1390. // inner neutral definitions
  1391. #define        (kNeutralInnerRadius,            0.3)
  1392. #define        (kNeutralOuterRadius,            0.4)
  1393. #define        (kNeutralOptimalFactor,            0.7)
  1394. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1395. #define        (kInnerNeutralPercentLand,        0.19)
  1396. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1397. #define        (kInnerNeutralTreePercentage,          0.15)
  1398. #define        (kInnerNeutralLandChaos,        0.8)
  1399. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1400. #define        (kInnerNeutralFlatChaos,        0.8)
  1401. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1402.  
  1403. //////////////////////////////////////////////////////////////////////
  1404. // outer neutral definitions
  1405. #define        (kNumOuterNeutrals,            Between(10, 10))
  1406. #define        (kOuterNeutralPercentLand,        0.2)
  1407. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1408. #define        (kOuterNeutralTreePercentage,          0.25)
  1409. #define        (kOuterNeutralLandChaos,        0.8)
  1410. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1411. #define        (kOuterNeutralFlatChaos,        0.8)
  1412. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1413.  
  1414. //////////////////////////////////////////////////////////////////////
  1415. // resource definitions
  1416. #define        (kMaxResourceElevation,            4)
  1417. #define        (kResourceToEdgeDistance,        2)
  1418. #define        (kResourceToWaterDistance,        4)
  1419.  
  1420. #define        (kAnimalPerPlayer,            0)
  1421. #define        (kAnimalPerNeutral,            0)
  1422.  
  1423. #define        (kBerryPerPlayer,                1)
  1424. #define        (kBerryPerNeutral,            0)
  1425.  
  1426. #define        (kFishPerPlayer,                0)
  1427. #define        (kFishPerNeutral,                0)
  1428.  
  1429. #define        (kGoldPerPlayer,                2)
  1430. #define        (kGoldPerNeutral,                2)
  1431.  
  1432. #define        (kOilPerPlayer,                0)
  1433. #define        (kOilPerNeutral,                0)
  1434.  
  1435. #define        (kSteelPerPlayer,                2)
  1436. #define        (kSteelPerNeutral,            2)
  1437.  
  1438. #define        (kStonePerPlayer,                1)
  1439. #define        (kStonePerNeutral,            5)
  1440.  
  1441. #define        (kTreePerPlayer,                0)
  1442. #define        (kTreePerNeutral,                0)
  1443.  
  1444.  
  1445. //////////////////////////////////////////////////////////////////////
  1446. // forest definitions
  1447. #define        (kForestFreeRadius,                7.0)
  1448. #define        (kForestsPerPlayer,                1 )
  1449. #define        (kForestChaosLevel,                1)
  1450. #define        (kMaxClumpsPerForest,                  2)
  1451.  
  1452. #elif Is16Players
  1453. //////////////////////////////////////////////////////////////////////
  1454. // 16 PLAYERS...
  1455. //////////////////////////////////////////////////////////////////////
  1456.  
  1457. //////////////////////////////////////////////////////////////////////
  1458. // terrain definitions
  1459. #define        (kMaxIntElevation,            15)
  1460. #define        (kElevationScale,                Between(1, 1))
  1461. #define        (kHeightMapChaos,                Between(20, 60))
  1462.  
  1463. #define        (kMinimumStartPositionToMapEdge    2)
  1464. #define        (kOuterPushFromMapCenter        20)
  1465. #define        (kInnerPushFromMapCenter         0)    
  1466.                                             
  1467. //////////////////////////////////////////////////////////////////////
  1468. // player definitions
  1469. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1470. #define        (kPlayerInnerRadius,            0.6)
  1471. #define        (kPlayerOuterRadius,            0.95)
  1472. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1473. #define        (kPlayerPercentFlat,            Between(.9, .9))
  1474. #define        (kPlayerLandChaos,            0.8)
  1475. #define        (kPlayerLandClumps,            Between(2, 2))
  1476. #define        (kPlayerFlatChaos,            0.8)
  1477. #define        (kPlayerFlatClumps,            Between(1, 2))
  1478. #define        (kPlayerTreePercentage,            0.08)
  1479.  
  1480. //////////////////////////////////////////////////////////////////////
  1481. // inner neutral definitions
  1482. #define        (kNeutralInnerRadius,            0.3)
  1483. #define        (kNeutralOuterRadius,            0.4)
  1484. #define        (kNeutralOptimalFactor,            0.7)
  1485. #define        (kNumInnerNeutrals,                 Between(10, 10))
  1486. #define        (kInnerNeutralPercentLand,        0.19)
  1487. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1488. #define        (kInnerNeutralTreePercentage,          0.15)
  1489. #define        (kInnerNeutralLandChaos,        0.8)
  1490. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1491. #define        (kInnerNeutralFlatChaos,        0.8)
  1492. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1493.  
  1494. //////////////////////////////////////////////////////////////////////
  1495. // outer neutral definitions
  1496. #define        (kNumOuterNeutrals,            Between(10, 10))
  1497. #define        (kOuterNeutralPercentLand,        0.2)
  1498. #define        (kOuterNeutralPercentFlat,        Between(0.85, 0.85))
  1499. #define        (kOuterNeutralTreePercentage,          0.25)
  1500. #define        (kOuterNeutralLandChaos,        0.8)
  1501. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1502. #define        (kOuterNeutralFlatChaos,        0.8)
  1503. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1504.  
  1505. //////////////////////////////////////////////////////////////////////
  1506. // resource definitions
  1507. #define        (kMaxResourceElevation,            4)
  1508. #define        (kResourceToEdgeDistance,        2)
  1509. #define        (kResourceToWaterDistance,        4)
  1510.  
  1511. #define        (kAnimalPerPlayer,            0)
  1512. #define        (kAnimalPerNeutral,            0)
  1513.  
  1514. #define        (kBerryPerPlayer,                1)
  1515. #define        (kBerryPerNeutral,            0)
  1516.  
  1517. #define        (kFishPerPlayer,                0)
  1518. #define        (kFishPerNeutral,                0)
  1519.  
  1520. #define        (kGoldPerPlayer,                2)
  1521. #define        (kGoldPerNeutral,                2)
  1522.  
  1523. #define        (kOilPerPlayer,                0)
  1524. #define        (kOilPerNeutral,                0)
  1525.  
  1526. #define        (kSteelPerPlayer,                2)
  1527. #define        (kSteelPerNeutral,            2)
  1528.  
  1529. #define        (kStonePerPlayer,                1)
  1530. #define        (kStonePerNeutral,            5)
  1531.  
  1532. #define        (kTreePerPlayer,                0)
  1533. #define        (kTreePerNeutral,                0)
  1534.  
  1535.  
  1536. //////////////////////////////////////////////////////////////////////
  1537. // forest definitions
  1538. #define        (kForestFreeRadius,                7.0)
  1539. #define        (kForestsPerPlayer,                1 )
  1540. #define        (kForestChaosLevel,                1)
  1541. #define        (kMaxClumpsPerForest,                  2)
  1542.  
  1543.  
  1544. //////////////////////////////////////////////////////////////////////
  1545. // End of if...elif... command
  1546. #endif
  1547.  
  1548. #endif        // NOTDEFINED(HIGHLANDS_SMALL_RMV)
  1549.